{
 "cells": [
  {
   "cell_type": "code",
   "id": "initial_id",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2025-02-07T01:57:04.595050Z",
     "start_time": "2025-02-07T01:57:02.117894Z"
    }
   },
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import sklearn\n",
    "import pandas as pd\n",
    "import os\n",
    "import sys\n",
    "import time\n",
    "from tqdm.auto import tqdm\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "print(sys.version_info)\n",
    "for module in mpl, np, pd, sklearn, torch:\n",
    "    print(module.__name__, module.__version__)\n",
    "\n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=12, micro=3, releaselevel='final', serial=0)\n",
      "matplotlib 3.10.0\n",
      "numpy 1.26.4\n",
      "pandas 2.2.3\n",
      "sklearn 1.6.0\n",
      "torch 2.6.0+cpu\n",
      "cpu\n"
     ]
    }
   ],
   "execution_count": 3
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 加载数据",
   "id": "92a19dd204058cd"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T01:57:05.560687Z",
     "start_time": "2025-02-07T01:57:04.596060Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from torchvision import datasets\n",
    "from torchvision.transforms import ToTensor\n",
    "\n",
    "# fashion_mnist图像分类数据集\n",
    "train_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=True,\n",
    "    download=True,\n",
    "    transform=ToTensor()\n",
    ")\n",
    "\n",
    "test_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=False,\n",
    "    download=True,\n",
    "    transform=ToTensor()\n",
    ")\n",
    "\n",
    "train_loader = torch.utils.data.DataLoader(train_ds, batch_size=16, shuffle=True)\n",
    "val_loader = torch.utils.data.DataLoader(test_ds, batch_size=16, shuffle=False)"
   ],
   "id": "5b2bfa747663d0a0",
   "outputs": [],
   "execution_count": 4
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T01:57:09.233174Z",
     "start_time": "2025-02-07T01:57:05.561691Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from torchvision.transforms import Normalize\n",
    "\n",
    "\n",
    "# 遍历train_ds得到每张图片，计算每个通道的均值和方差\n",
    "def cal_mean_std(ds):\n",
    "    mean = 0.\n",
    "    std = 0.\n",
    "    for img, _ in ds:  # 遍历每张图片,img.shape=[1,28,28]\n",
    "        mean += img.mean(dim=(1, 2))\n",
    "        std += img.std(dim=(1, 2))\n",
    "    mean /= len(ds)\n",
    "    std /= len(ds)\n",
    "    return mean, std\n",
    "\n",
    "\n",
    "print(cal_mean_std(train_ds))\n",
    "# 0.2860， 0.3205\n",
    "transforms = nn.Sequential(\n",
    "    Normalize([0.2860], [0.3205])  # 这里的均值和标准差是通过train_ds计算得到的\n",
    ")\n"
   ],
   "id": "a53fcd4642407473",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(tensor([0.2860]), tensor([0.3205]))\n"
     ]
    }
   ],
   "execution_count": 5
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "# 定义模型\n",
    "这里没有用`nn.Linear`的默认初始化，而是采用了xavier均匀分布去初始化全连接层的权重\n",
    "\n",
    "xavier初始化出自论文 《Understanding the difficulty of training deep feedforward neural networks》，适用于使用`tanh`和`sigmoid`激活函数的方法。当然，这里的模型采用的是`relu`激活函数，采用He初始化（何凯明初始化）会更加合适。\n",
    "\n",
    "|神经网络层数|初始化方式|early stop at epoch| val_loss | vla_acc|\n",
    "|-|-|-|-|-|\n",
    "|20|默认|\n",
    "|20|xaviier_uniform|\n",
    "|20|he_uniform|\n",
    "|...|\n",
    "\n",
    "He初始化出自论文 《Delving deep into rectifiers: Surpassing human-level performance on ImageNet classification》"
   ],
   "id": "64bf59205d3cfa1f"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "***Dropout 的基本原理***\n",
    "\n",
    "作用: 在训练过程中，随机将一部分神经元的输出置为 0，使得模型不能过度依赖某些特定的神经元。\n",
    "\n",
    "参数:\n",
    "\n",
    "p: 神经元被丢弃的概率（取值范围为 [0, 1)）。\n",
    "\n",
    "训练阶段: 每个神经元以概率 p 被丢弃，以概率 1-p 被保留。\n",
    "\n",
    "测试阶段: 所有神经元都被保留，但输出值需要乘以 1-p，以保持期望值不变。\n",
    "\n",
    "2. AlphaDropout 的特殊性\n",
    "适用场景: 主要用于自归一化神经网络（如使用 SELU 激活函数的网络）。\n",
    "\n",
    "特点:\n",
    "\n",
    "保持输入数据的均值和方差不变。\n",
    "\n",
    "不仅将神经元置为 0，还会对保留的神经元进行缩放，以确保自归一化性质。\n",
    "\n",
    "数学原理:\n",
    "\n",
    "对于保留的神经元，输出值被缩放为 (1 - p) * x。\n",
    "\n",
    "对于丢弃的神经元，输出值被设置为 0，同时调整其他神经元的输出以保持均值和方差。\n",
    "\n",
    "3. 为什么使用 AlphaDropout\n",
    "防止过拟合: 通过随机丢弃神经元，减少神经元之间的共适应性，增强模型的泛化能力。\n",
    "\n",
    "保持自归一化: 在自归一化网络中，AlphaDropout 能够保持输入数据的均值和方差，确保网络的稳定性。\n",
    "\n",
    "适用于 SELU 激活函数: SELU 激活函数要求输入数据具有特定的均值和方差，AlphaDropout 能够满足这一要求。"
   ],
   "id": "cb7b6d52f38fc227"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T01:57:09.246518Z",
     "start_time": "2025-02-07T01:57:09.234199Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 定义一个名为 NeuralNetwork 的类，继承自 nn.Module\n",
    "# 继承 nn.Module 可以使用 PyTorch 提供的神经网络功能\n",
    "class NeuralNetwork(nn.Module):\n",
    "\n",
    "    # 定义类的构造函数，接受一个参数 layers_num，表示隐藏层的数量，默认值为 2。\n",
    "    # 初始化网络的层结构和参数\n",
    "    def __init__(self, layers_num=2):\n",
    "\n",
    "        # 调用父类的构造函数\n",
    "        # 确保 NeuralNetwork 类正确初始化\n",
    "        super().__init__()\n",
    "\n",
    "        # 将 transforms 赋值给类的属性 self.transforms\n",
    "        self.transforms = transforms\n",
    "\n",
    "        # 定义一个 Flatten 层，用于将输入数据展平为一维向量\n",
    "        self.flatten = nn.Flatten()\n",
    "\n",
    "        # 定义一个 Sequential 容器，包含一个全连接层和一个 ReLU 激活函数\n",
    "        # 构建网络的第一层\n",
    "        self.linear_relu_stack = nn.Sequential(\n",
    "            nn.Linear(28 * 28, 100),\n",
    "            nn.SELU(),\n",
    "\n",
    "            # 创建一个 AlphaDropout 层，p=0.2 表示每个神经元在训练时有 20% 的概率被置为 0。\n",
    "            # Dropout 是一种正则化技术，通过在训练过程中随机丢弃神经元，防止模型过拟合。\n",
    "            nn.AlphaDropout(p=0.2)  # 增加dropout，p=0.2表示以0.2的概率将某些神经元置0，防止过拟合\n",
    "        )\n",
    "\n",
    "        # 循环添加隐藏层，每层包括一个全连接层和一个 ReLU 激活函数\n",
    "        # 动态构建隐藏层，使网络深度可配置\n",
    "        for i in range(1, layers_num):\n",
    "            self.linear_relu_stack.add_module(f\"Linear_{i}\", nn.Linear(100, 100))\n",
    "            self.linear_relu_stack.add_module(f\"selu\", nn.SELU())  # 这里采用SELU激活函数\n",
    "            nn.AlphaDropout(p=0.2)  # 增加dropout\n",
    "\n",
    "        # 定义输出层\n",
    "        self.linear_relu_stack.add_module(\"Output Layer\", nn.Linear(100, 10))\n",
    "\n",
    "        # 调用 init_weights 方法初始化网络参数\n",
    "        # 避免参数初始值不合适导致训练困难\n",
    "        self.init_weights()\n",
    "\n",
    "        # 定义 init_weights 方法，用于初始化网络参数\n",
    "        # self.modules(): 获取网络中的所有模块\n",
    "        # isinstance(m, nn.Linear): 检查模块是否为全连接层。\n",
    "        # nn.init.xavier_uniform_(m.weight): 使用 Xavier 初始化方法初始化权重。\n",
    "        # nn.init.zeros_(m.bias): 将偏置初始化为 0。\n",
    "        # 合适的参数初始化可以加速模型收敛\n",
    "\n",
    "    def init_weights(self):\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, nn.Linear):\n",
    "                nn.init.xavier_uniform_(m.weight)\n",
    "                nn.init.zeros_(m.bias)\n",
    "\n",
    "        # 定义 forward 方法，实现网络的前向传播\n",
    "        # 输入数据经过 transforms 处理后，经过 flatten 层展平为一维向量\n",
    "        # 经过 linear_relu_stack 层，输出网络预测结果\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.transforms(x)\n",
    "        x = self.flatten(x)\n",
    "        logits = self.linear_relu_stack(x)\n",
    "        return logits\n",
    "\n",
    "\n",
    "# 计算并打印模型的参数数量和形状\n",
    "# NeuralNetwork(20).named_parameters(): 获取模型的所有参数及其名称。\n",
    "# np.prod(value.shape): 计算参数的个数（形状的乘积）。\n",
    "# total += np.prod(value.shape): 累加所有参数的数量。\n",
    "total = 0\n",
    "for idx, (key, value) in enumerate(NeuralNetwork(20).named_parameters()):\n",
    "    print(f\"Linear_{idx // 2:>02}\\tparamerters num: {np.prod(value.shape)}\")\n",
    "    print(f\"Linear_{idx // 2:>02}\\tshape: {value.shape}\")\n",
    "    total += np.prod(value.shape)\n",
    "total"
   ],
   "id": "2bfa7060ce08fe71",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Linear_00\tparamerters num: 78400\n",
      "Linear_00\tshape: torch.Size([100, 784])\n",
      "Linear_00\tparamerters num: 100\n",
      "Linear_00\tshape: torch.Size([100])\n",
      "Linear_01\tparamerters num: 10000\n",
      "Linear_01\tshape: torch.Size([100, 100])\n",
      "Linear_01\tparamerters num: 100\n",
      "Linear_01\tshape: torch.Size([100])\n",
      "Linear_02\tparamerters num: 10000\n",
      "Linear_02\tshape: torch.Size([100, 100])\n",
      "Linear_02\tparamerters num: 100\n",
      "Linear_02\tshape: torch.Size([100])\n",
      "Linear_03\tparamerters num: 10000\n",
      "Linear_03\tshape: torch.Size([100, 100])\n",
      "Linear_03\tparamerters num: 100\n",
      "Linear_03\tshape: torch.Size([100])\n",
      "Linear_04\tparamerters num: 10000\n",
      "Linear_04\tshape: torch.Size([100, 100])\n",
      "Linear_04\tparamerters num: 100\n",
      "Linear_04\tshape: torch.Size([100])\n",
      "Linear_05\tparamerters num: 10000\n",
      "Linear_05\tshape: torch.Size([100, 100])\n",
      "Linear_05\tparamerters num: 100\n",
      "Linear_05\tshape: torch.Size([100])\n",
      "Linear_06\tparamerters num: 10000\n",
      "Linear_06\tshape: torch.Size([100, 100])\n",
      "Linear_06\tparamerters num: 100\n",
      "Linear_06\tshape: torch.Size([100])\n",
      "Linear_07\tparamerters num: 10000\n",
      "Linear_07\tshape: torch.Size([100, 100])\n",
      "Linear_07\tparamerters num: 100\n",
      "Linear_07\tshape: torch.Size([100])\n",
      "Linear_08\tparamerters num: 10000\n",
      "Linear_08\tshape: torch.Size([100, 100])\n",
      "Linear_08\tparamerters num: 100\n",
      "Linear_08\tshape: torch.Size([100])\n",
      "Linear_09\tparamerters num: 10000\n",
      "Linear_09\tshape: torch.Size([100, 100])\n",
      "Linear_09\tparamerters num: 100\n",
      "Linear_09\tshape: torch.Size([100])\n",
      "Linear_10\tparamerters num: 10000\n",
      "Linear_10\tshape: torch.Size([100, 100])\n",
      "Linear_10\tparamerters num: 100\n",
      "Linear_10\tshape: torch.Size([100])\n",
      "Linear_11\tparamerters num: 10000\n",
      "Linear_11\tshape: torch.Size([100, 100])\n",
      "Linear_11\tparamerters num: 100\n",
      "Linear_11\tshape: torch.Size([100])\n",
      "Linear_12\tparamerters num: 10000\n",
      "Linear_12\tshape: torch.Size([100, 100])\n",
      "Linear_12\tparamerters num: 100\n",
      "Linear_12\tshape: torch.Size([100])\n",
      "Linear_13\tparamerters num: 10000\n",
      "Linear_13\tshape: torch.Size([100, 100])\n",
      "Linear_13\tparamerters num: 100\n",
      "Linear_13\tshape: torch.Size([100])\n",
      "Linear_14\tparamerters num: 10000\n",
      "Linear_14\tshape: torch.Size([100, 100])\n",
      "Linear_14\tparamerters num: 100\n",
      "Linear_14\tshape: torch.Size([100])\n",
      "Linear_15\tparamerters num: 10000\n",
      "Linear_15\tshape: torch.Size([100, 100])\n",
      "Linear_15\tparamerters num: 100\n",
      "Linear_15\tshape: torch.Size([100])\n",
      "Linear_16\tparamerters num: 10000\n",
      "Linear_16\tshape: torch.Size([100, 100])\n",
      "Linear_16\tparamerters num: 100\n",
      "Linear_16\tshape: torch.Size([100])\n",
      "Linear_17\tparamerters num: 10000\n",
      "Linear_17\tshape: torch.Size([100, 100])\n",
      "Linear_17\tparamerters num: 100\n",
      "Linear_17\tshape: torch.Size([100])\n",
      "Linear_18\tparamerters num: 10000\n",
      "Linear_18\tshape: torch.Size([100, 100])\n",
      "Linear_18\tparamerters num: 100\n",
      "Linear_18\tshape: torch.Size([100])\n",
      "Linear_19\tparamerters num: 10000\n",
      "Linear_19\tshape: torch.Size([100, 100])\n",
      "Linear_19\tparamerters num: 100\n",
      "Linear_19\tshape: torch.Size([100])\n",
      "Linear_20\tparamerters num: 1000\n",
      "Linear_20\tshape: torch.Size([10, 100])\n",
      "Linear_20\tparamerters num: 10\n",
      "Linear_20\tshape: torch.Size([10])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "271410"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 6
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 训练",
   "id": "d911b185989182f4"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T01:57:09.277450Z",
     "start_time": "2025-02-07T01:57:09.246518Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "\n",
    "# 这是一个装饰器，用于禁用梯度计算。\n",
    "# 在评估模型时，我们不需要计算梯度，因为不会进行反向传播和参数更新。禁用梯度计算可以减少内存消耗并加速计算。\n",
    "@torch.no_grad()\n",
    "# 定义评估函数，接受三个参数：model（要评估的模型）、dataloader（数据加载器，用于提供评估数据）、loss_fct（损失函数）。\n",
    "# 用于评估模型在给定数据集上的性能。\n",
    "# 通过封装评估过程，可以方便地在不同模型和数据集上重复使用。\n",
    "def evaluating(model, dataloader, loss_fct):\n",
    "    # 初始化三个空列表，分别用于存储每个批次的损失、预测标签和真实标签。\n",
    "    # 用于累积所有批次的损失和标签，以便后续计算平均损失和准确率。\n",
    "    # 累积所有批次的结果可以更准确地反映模型在整个数据集上的性能。\n",
    "    loss_list = []  # 记录损失\n",
    "    pred_list = []  # 记录预测\n",
    "    label_list = []  # 记录标签\n",
    "\n",
    "    # 遍历数据加载器中的每个批次，datas 是输入数据，labels 是对应的真实标签\n",
    "    for datas, labels in dataloader:\n",
    "        # 将输入数据和标签移动到指定的设备（GPU或CPU），转到GPU可以加速计算\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "\n",
    "        # 将输入数据传递给模型，得到模型的输出 logits（通常是未归一化的预测分数）。\n",
    "        # 模型的前向传播过程，计算输入数据对应的输出。通过模型的输出可以计算损失和预测标签。\n",
    "        logits = model(datas)\n",
    "\n",
    "        # 将当前批次的损失值（转换为 Python 浮点数）添加到 loss_list 中。\n",
    "        # loss.item() 将张量中的单个值提取为 Python 浮点数。\n",
    "        # 累积所有批次的损失值，以便后续计算平均损失。\n",
    "        loss = loss_fct(logits, labels)\n",
    "        loss_list.append(loss.item())\n",
    "\n",
    "        # 通过 argmax 函数获取模型预测的类别标签。axis=-1 表示在最后一个维度上取最大值对应的索引。\n",
    "        # logits 通常是每个类别的分数，argmax 找到分数最高的类别作为预测结果。\n",
    "        # 将模型的输出转换为具体的类别标签，便于与真实标签进行比较。\n",
    "        preds = logits.argmax(axis=-1)\n",
    "\n",
    "        # 将预测标签从 GPU 移动到 CPU，并转换为 NumPy 数组，再转换为 Python 列表，然后添加到 pred_list 中。\n",
    "        # preds.cpu().numpy().tolist() 将张量转换为 Python 列表。\n",
    "        # 累积所有批次的预测标签，以便后续计算准确率。\n",
    "        pred_list.extend(preds.cpu().numpy().tolist())\n",
    "        label_list.extend(labels.cpu().numpy().tolist())\n",
    "\n",
    "    #计算预测标签和真实标签之间的准确率\n",
    "    acc = accuracy_score(label_list, pred_list)\n",
    "\n",
    "    #返回所有批次的平均损失和准确率。\n",
    "    return np.mean(loss_list), acc"
   ],
   "id": "f61f638900a4b1f3",
   "outputs": [],
   "execution_count": 7
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "### Tensorboard 可视化",
   "id": "bf15f06c65aecdc5"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T01:57:11.436055Z",
     "start_time": "2025-02-07T01:57:09.278455Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from torch.utils.tensorboard import SummaryWriter\n",
    "\n",
    "\n",
    "class TensorBoardCallback:\n",
    "    def __init__(self, log_dir, flush_secs=10):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            log_dir (str): dir to write log.\n",
    "            flush_secs (int, optional): write to dsk each flush_secs seconds. Defaults to 10.\n",
    "        \"\"\"\n",
    "        self.writer = SummaryWriter(log_dir=log_dir,\n",
    "                                    flush_secs=flush_secs)  # 实例化SummaryWriter, log_dir是log存放路径，flush_secs是每隔多少秒写入磁盘\n",
    "\n",
    "    def draw_model(self, model, input_shape):  #graphs\n",
    "        self.writer.add_graph(model, input_to_model=torch.randn(input_shape))  # 画模型图\n",
    "\n",
    "    def add_loss_scalars(self, step, loss, val_loss):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/loss\",\n",
    "            tag_scalar_dict={\"loss\": loss, \"val_loss\": val_loss},\n",
    "            global_step=step,\n",
    "        )  # 画loss曲线, main_tag是主tag，tag_scalar_dict是子tag，global_step是步数\n",
    "\n",
    "    def add_acc_scalars(self, step, acc, val_acc):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/accuracy\",\n",
    "            tag_scalar_dict={\"accuracy\": acc, \"val_accuracy\": val_acc},\n",
    "            global_step=step,\n",
    "        )  # 画acc曲线, main_tag是主tag，tag_scalar_dict是子tag，global_step是步数\n",
    "\n",
    "    def add_lr_scalars(self, step, learning_rate):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/learning_rate\",\n",
    "            tag_scalar_dict={\"learning_rate\": learning_rate},\n",
    "            global_step=step,\n",
    "        )  # 画lr曲线, main_tag是主tag，tag_scalar_dict是子tag，global_step是步数\n",
    "\n",
    "    def __call__(self, step, **kwargs):\n",
    "        # add loss,把loss，val_loss取掉，画loss曲线\n",
    "        loss = kwargs.pop(\"loss\", None)\n",
    "        val_loss = kwargs.pop(\"val_loss\", None)\n",
    "        if loss is not None and val_loss is not None:\n",
    "            self.add_loss_scalars(step, loss, val_loss)  # 画loss曲线\n",
    "        # add acc\n",
    "        acc = kwargs.pop(\"acc\", None)\n",
    "        val_acc = kwargs.pop(\"val_acc\", None)\n",
    "        if acc is not None and val_acc is not None:\n",
    "            self.add_acc_scalars(step, acc, val_acc)  # 画acc曲线\n",
    "        # add lr\n",
    "        learning_rate = kwargs.pop(\"lr\", None)\n",
    "        if learning_rate is not None:\n",
    "            self.add_lr_scalars(step, learning_rate)  # 画lr曲线\n"
   ],
   "id": "8c2df3129dcef4b6",
   "outputs": [],
   "execution_count": 8
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "### 保存最好模型",
   "id": "e90b3a3c89900c08"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T01:57:11.442473Z",
     "start_time": "2025-02-07T01:57:11.437185Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 定义一个名为 SaveCheckpointsCallback 的类。\n",
    "# 该类用于在训练过程中保存模型的检查点。封装保存检查点的逻辑，方便在训练过程中调用\n",
    "class SaveCheckpointsCallback:\n",
    "    \"\"\"\n",
    "    Callback to save model checkpoints during training.\n",
    "    \"\"\"\n",
    "\n",
    "    #定义类的构造函数，接受以下参数：\n",
    "    # save_dir: 检查点保存的目录。\n",
    "    # save_step: 每隔多少步保存一次检查点，默认值为 500。\n",
    "    # save_best_only: 是否只保存性能最好的检查点，默认值为 True\n",
    "    # 原理：初始化回调类的参数和状态\n",
    "    def __init__(self, save_dir, save_step=500, save_best_only=True):\n",
    "\n",
    "        # 将传入的参数保存为类的属性\n",
    "        self.save_dir = save_dir\n",
    "        self.save_step = save_step\n",
    "        self.save_best_only = save_best_only\n",
    "\n",
    "        # 初始化一个变量 best_metrics，用于记录当前最好的性能指标值，初始值为 -1\n",
    "        # 原理: 用于比较当前模型的性能是否优于之前保存的模型,当 save_best_only 为 True 时，只保存性能最好的模型\n",
    "        self.best_metrics = -1\n",
    "\n",
    "        # 检查保存目录是否存在，如果不存在则创建该目录\n",
    "        # os.path.exists()用于判断路径是否存在, os.mkdir()用于创建目录\n",
    "        if not os.path.exists(self.save_dir):\n",
    "            os.mkdir(self.save_dir)\n",
    "\n",
    "    # 定义 __call__ 方法，使类的实例可以像函数一样调用。参数包括：\n",
    "    # step: 当前训练的步数。\n",
    "    # state_dict: 模型的状态字典（包含模型参数）。\n",
    "    # metric: 当前模型的性能指标值（如验证集准确率），默认为 None\n",
    "    # 在训练过程中定期调用该方法，保存检查点\n",
    "    def __call__(self, step, state_dict, metric=None):\n",
    "\n",
    "        # 检查当前步数是否是 save_step 的倍数，如果不是则直接返回\n",
    "        # 控制保存检查点的频率，避免频繁保存\n",
    "        if step % self.save_step > 0:\n",
    "            return\n",
    "\n",
    "        # 检查是否只保存性能最好的检查点\n",
    "        # 根据 save_best_only 的值决定保存策略,提供两种保存策略：定期保存和只保存最佳模型\n",
    "        if self.save_best_only:\n",
    "\n",
    "            # 如果 save_best_only 为 True，则要求 metric 不能为 None。\n",
    "            # 原理: 使用 assert 断言确保 metric 有值。如果 metric 为 None，无法判断模型性能是否更好，因此需要提前检查\n",
    "            assert metric is not None\n",
    "\n",
    "            # 检查当前模型的性能指标是否优于之前保存的最佳模型\n",
    "            # 只保存性能更好的模型，避免保存性能下降的模型\n",
    "            if metric >= self.best_metrics:\n",
    "                # 将模型的状态字典保存到指定目录下的 best.ckpt 文件中\n",
    "                # 使用 torch.save 保存模型参数。保存当前性能最好的模型，方便后续加载和使用\n",
    "                torch.save(state_dict, os.path.join(self.save_dir, \"best.ckpt\"))\n",
    "\n",
    "                # 更新 best_metrics 为当前模型的性能指标值\n",
    "                self.best_metrics = metric\n",
    "\n",
    "        # 如果 save_best_only 为 False，则执行以下逻辑\n",
    "        # 定期保存检查点，不关心模型性能是否更好\n",
    "        else:\n",
    "\n",
    "            # 将模型的状态字典保存到指定目录下，文件名为当前步数\n",
    "            torch.save(state_dict, os.path.join(self.save_dir, f\"{step}.ckpt\"))"
   ],
   "id": "a6f18fc340403b57",
   "outputs": [],
   "execution_count": 9
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "### 早停",
   "id": "4720c83f1ce2c823"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T01:57:11.448543Z",
     "start_time": "2025-02-07T01:57:11.443476Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 定义一个名为 EarlyStopCallback 的类.用于监控模型在验证集上的性能，并在性能不再提升时触发早停。\n",
    "# 封装早停的逻辑，方便在训练过程中调用\n",
    "class EarlyStopCallback:\n",
    "\n",
    "    # 定义类的构造函数，接受以下参数\n",
    "    # patience: 容忍的轮次数，默认值为 5。如果在 patience 轮内性能没有提升，则触发早停。\n",
    "    # min_delta: 性能提升的最小阈值，默认值为 0.01。只有当性能提升超过该阈值时，才认为模型有改进。\n",
    "    # 初始化早停回调的参数和状态\n",
    "    def __init__(self, patience=5, min_delta=0.01):\n",
    "\n",
    "        # 将传入的参数保存为类的属性\n",
    "        self.patience = patience\n",
    "        self.min_delta = min_delta\n",
    "\n",
    "        self.best_metric = -1  # 用于比较当前模型的性能是否优于之前的最佳性能\n",
    "\n",
    "        # 初始化一个计数器 counter，用于记录性能没有提升的连续轮次数，初始值为 0\n",
    "        # 当性能没有提升时，计数器增加；当性能提升时，计数器重置,用于判断是否达到了早停的条件\n",
    "        self.counter = 0\n",
    "\n",
    "    # 训练过程中定期调用该方法，更新早停状态\n",
    "    def __call__(self, metric):\n",
    "\n",
    "        # 检查当前性能指标是否比之前的最佳性能提升了至少 min_delta\n",
    "        # 避免微小的波动触发早停,当性能有显著提升时，才认为模型有改进\n",
    "        if metric >= self.best_metric + self.min_delta:\n",
    "\n",
    "            self.best_metric = metric  # 记录当前最佳性能\n",
    "            self.counter = 0  # 性能有提升时，重置计数器,重新开始计算性能没有提升的连续轮次数\n",
    "\n",
    "        # 性能没有提升时，增加计数器\n",
    "        else:\n",
    "            self.counter += 1  # 记录性能没有提升的连续轮次数\n",
    "\n",
    "    # 定义一个只读属性 early_stop，用于判断是否触发早停。\n",
    "    # 使用 @property 装饰器将方法转换为属性。方便外部代码通过属性访问早停状态。\n",
    "    @property\n",
    "    def early_stop(self):\n",
    "\n",
    "        # 检查计数器 counter 是否大于或等于 patience\n",
    "        # 提供早停的触发条件\n",
    "        return self.counter >= self.patience"
   ],
   "id": "4d832bdbea1d7eec",
   "outputs": [],
   "execution_count": 10
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T01:57:11.455924Z",
     "start_time": "2025-02-07T01:57:11.449547Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 定义一个名为 training 的函数，用于训练模型。参数包括：\n",
    "# model: 要训练的模型。\n",
    "# train_loader: 训练数据的数据加载器。\n",
    "# val_loader: 验证数据的数据加载器。\n",
    "# epoch: 训练的轮数。\n",
    "# loss_fct: 损失函数。\n",
    "# optimizer: 优化器。\n",
    "# eval_step: 每隔多少步评估一次验证集性能，默认值为 500。\n",
    "# 该函数通过遍历训练数据，更新模型参数，并定期评估验证集性能。封装训练过程，方便重复使用\n",
    "def training(\n",
    "        model,\n",
    "        train_loader,\n",
    "        val_loader,\n",
    "        epoch,\n",
    "        loss_fct,\n",
    "        optimizer,\n",
    "        tensorboard_callback=None,\n",
    "        save_ckpt_callback=None,\n",
    "        early_stop_callback=None,\n",
    "        eval_step=500,\n",
    "):\n",
    "    # 初始化一个字典 record_dict，用于记录训练和验证过程中的损失和准确率。\n",
    "    # 通过记录训练和验证的性能，可以分析模型的训练过程。方便后续绘制训练曲线或分析模型表现。\n",
    "    record_dict = {\n",
    "        \"train\": [],  # \"train\": 存储训练集的损失和准确率。\n",
    "        \"val\": []  # \"val\": 存储验证集的损失和准确率。\n",
    "    }\n",
    "\n",
    "    # 初始化一个全局步数计数器 global_step，用于记录当前训练的步数。\n",
    "    # 步数用于控制何时评估验证集性能。通过步数而不是轮数来控制评估频率，更灵活。\n",
    "    global_step = 0\n",
    "\n",
    "    # 将模型设置为训练模式。在训练模式下，模型会启用一些特定于训练的功能（如 Dropout 和 BatchNorm）。\n",
    "    # 确保模型在训练时行为正确。\n",
    "    model.train()\n",
    "\n",
    "    # 使用 tqdm 创建一个进度条，总长度为 epoch * len(train_loader)，即总训练步数。\n",
    "    # tqdm 是一个进度条库，用于显示训练进度。\n",
    "    # 提供可视化的训练进度，方便监控训练过程。\n",
    "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "\n",
    "        # 外层循环，遍历每个训练轮次。每个轮次会遍历整个训练数据集一次。\n",
    "        # 多轮训练可以提高模型的性能。\n",
    "        for epoch_id in range(epoch):\n",
    "\n",
    "            # 内层循环，遍历训练数据加载器中的每个批次。\n",
    "            for datas, labels in train_loader:\n",
    "\n",
    "                # 将输入数据和标签移动到指定的设备（GPU或CPU），转到GPU可以加速计算\n",
    "                datas = datas.to(device)\n",
    "                labels = labels.to(device)\n",
    "\n",
    "                # 清除优化器中之前的梯度。\n",
    "                # PyTorch 会累积梯度，因此在每次反向传播前需要清除之前的梯度。避免梯度累积导致错误的参数更新。\n",
    "                optimizer.zero_grad()\n",
    "\n",
    "                logits = model(datas)  # 模型前向计算\n",
    "                loss = loss_fct(logits, labels)  # 计算损失\n",
    "\n",
    "                # 计算损失相对于模型参数的梯度。\n",
    "                # 反向传播算法，通过链式法则计算梯度。梯度用于更新模型参数，以最小化损失。\n",
    "                loss.backward()\n",
    "\n",
    "                # 使用优化器更新模型参数。\n",
    "                optimizer.step()\n",
    "\n",
    "                preds = logits.argmax(axis=-1)  # 通过 argmax 函数获取模型预测的类别标签。\n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())  # 计算当前批次的准确率\n",
    "                loss = loss.cpu().item()  # 将损失值从 GPU 移动到 CPU，并转换为 Python 浮点数。方便记录和打印损失值。\n",
    "\n",
    "                # 将当前批次的损失、准确率和步数记录到 record_dict[\"train\"] 中\n",
    "                # 累积训练过程中的性能指标。方便后续分析训练过程\n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss, \"acc\": acc, \"step\": global_step\n",
    "                })\n",
    "\n",
    "                # 每隔 eval_step 步评估一次验证集性能。\n",
    "                # 使用 global_step 控制评估频率。定期评估验证集性能，避免过拟合。\n",
    "                if global_step % eval_step == 0:\n",
    "                    # 将模型设置为评估模式\n",
    "                    model.eval()\n",
    "\n",
    "                    # 调用 evaluating 函数计算验证集的损失和准确率\n",
    "                    # 在验证集上评估模型性能。验证集性能反映了模型的泛化能力。\n",
    "                    val_loss, val_acc = evaluating(model, val_loader, loss_fct)\n",
    "\n",
    "                    # 将验证集的损失、准确率和步数记录到 record_dict[\"val\"] 中。\n",
    "                    record_dict[\"val\"].append({\n",
    "                        \"loss\": val_loss, \"acc\": val_acc, \"step\": global_step\n",
    "                    })\n",
    "\n",
    "                    # 将模型设置为训练模式\n",
    "                    model.train()\n",
    "\n",
    "                    # 1. 使用 tensorboard 可视化\n",
    "                    if tensorboard_callback is not None:\n",
    "                        # 调用 tensorboard 回调函数，记录训练过程中的关键指标\n",
    "                        tensorboard_callback(\n",
    "                            global_step,  # 当前训练的全局步数，用于在 TensorBoard 中标识不同的训练阶段\n",
    "                            loss=loss, val_loss=val_loss,  # 记录训练集和验证集的损失值，用于监控模型在训练和验证集上的表现\n",
    "                            acc=acc, val_acc=val_acc,  # 记录训练集和验证集的准确率，用于监控模型的分类性能\n",
    "                            lr=optimizer.param_groups[0][\"lr\"],  # 取出当前学习率，用于监控学习率的变化，确保学习率调整策略正常工作\n",
    "                        )\n",
    "\n",
    "                    # 2. 保存模型权重 save model checkpoint\n",
    "                    if save_ckpt_callback is not None:\n",
    "                        # 调用保存模型权重的回调函数，保存当前模型的权重\n",
    "                        save_ckpt_callback(\n",
    "                            global_step,  # 当前训练的全局步数，用于标识保存的模型权重对应的训练阶段\n",
    "                            model.state_dict(),  # 保存模型的当前状态字典（即模型的所有参数），以便后续可以恢复模型\n",
    "                            metric=val_acc  # 使用验证集的准确率作为指标，判断是否保存当前模型（通常只保存性能最好的模型）\n",
    "                        )\n",
    "\n",
    "                    # 3. 早停 Early Stop\n",
    "                    if early_stop_callback is not None:\n",
    "                        # 调用早停回调函数，监控验证集准确率是否不再提升\n",
    "                        early_stop_callback(val_acc)  # 传入验证集准确率，用于判断是否满足早停条件\n",
    "                        if early_stop_callback.early_stop:  # 检查是否触发了早停条件\n",
    "                            # 如果触发了早停条件，打印提示信息并结束训练\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict  # 返回训练记录字典，包含训练过程中的关键指标\n",
    "\n",
    "                # 增加全局步数计数器\n",
    "                # 记录当前训练的步数,控制评估频率和记录训练进度\n",
    "                global_step += 1\n",
    "\n",
    "                # 更新进度条\n",
    "                pbar.update(1)\n",
    "\n",
    "                # 在进度条中显示当前训练的轮次。\n",
    "                # 更新进度条的后缀信息。方便监控训练进度。\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "\n",
    "    # 返回记录的训练和验证性能的字典,包含训练和验证过程中的损失和准确率\n",
    "    return record_dict"
   ],
   "id": "a452d95c803a8a58",
   "outputs": [],
   "execution_count": 11
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T01:57:11.553251Z",
     "start_time": "2025-02-07T01:57:11.457928Z"
    }
   },
   "cell_type": "code",
   "source": [
    "epoch = 100\n",
    "\n",
    "# 实例化NeuralNetwork类，创建一个神经网络模型对象\n",
    "model = NeuralNetwork(layers_num=10)\n",
    "\n",
    "# 定义了一个损失函数使用的是交叉熵损失函数，这是分类问题中常用的损失函数。\n",
    "# CrossEntropyLoss 结合了 Softmax 激活函数和 Log Loss，内部先做softmax，再计算交叉熵，用于多类别分类问题。\n",
    "# 输入是未经过 Softmax 处理的 logits（原始预测分数），而目标标签应该是类别的索引\n",
    "loss_fct = nn.CrossEntropyLoss()\n",
    "\n",
    "# 优化器：用于更新模型的参数。\n",
    "# 这里使用的是 SGD（随机梯度下降，Stochastic Gradient Descent）优化算法。通过对每个数据点的梯度进行更新，快速地调整模型参数。\n",
    "# model.parameters()：这一部分是传入模型的所有参数，优化器将会基于这些参数计算梯度并进行更新。\n",
    "# lr：学习率，控制参数更新的步长。学习率越小，更新越慢；学习率越大，可能会导致训练不稳定。0.001 是一个比较常见的初始学习率。\n",
    "# momentum：动量是为了加速 SGD，避免在训练过程中振荡。动量值通常在 0 到 1 之间，0.9 是一个常用的选择。动量帮助优化器在上一次梯度的方向上继续前进，从而使得优化过程更为稳定。\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)\n",
    "\n",
    "# 实例化\n",
    "# 1. tensorboard 可视化\n",
    "tensorboard_callback = TensorBoardCallback(\"runs\")\n",
    "tensorboard_callback.draw_model(model, [1, 28, 28])\n",
    "# 2. 保存最佳模型\n",
    "save_ckpt_callback = SaveCheckpointsCallback(\"checkpoints/dropout\", save_best_only=True)\n",
    "# 3. 早停\n",
    "early_stop_callback = EarlyStopCallback(patience=10)"
   ],
   "id": "55fd51912633ca11",
   "outputs": [],
   "execution_count": 12
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T02:21:26.005378Z",
     "start_time": "2025-02-07T01:57:11.554255Z"
    }
   },
   "cell_type": "code",
   "source": [
    "record = training(\n",
    "    model,  # 要训练的模型\n",
    "    train_loader,  # 训练数据的数据加载器\n",
    "    val_loader,  # 验证数据的数据加载器\n",
    "    epoch,  # 训练的轮数\n",
    "    loss_fct,  # 损失函数\n",
    "    optimizer,  # 优化器\n",
    "    tensorboard_callback=None,  # tensorboard 可视化\n",
    "    save_ckpt_callback=save_ckpt_callback,  # 保存最佳模型\n",
    "    early_stop_callback=early_stop_callback,  # 早停\n",
    "    eval_step=len(train_loader)  # 每隔多少步评估一次验证集性能\n",
    ")"
   ],
   "id": "a715ad4ee2ef44c8",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "  0%|          | 0/375000 [00:00<?, ?it/s]"
      ],
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "5d058bab406c4ba48141aa9a9f1d5649"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Early stop at epoch 28 / global_step 105000\n"
     ]
    }
   ],
   "execution_count": 13
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T02:21:26.172355Z",
     "start_time": "2025-02-07T02:21:26.005378Z"
    }
   },
   "cell_type": "code",
   "source": [
    "#画线要注意的是损失是不一定在零到1之间的\n",
    "# 定义一个名为 plot_learning_curves 的函数，接受以下参数：\n",
    "# record_dict: 包含训练和验证记录的字典。\n",
    "# sample_step: 对训练数据进行采样的步长，默认值为 500。\n",
    "# 该函数用于可视化训练和验证过程中的性能指标。\n",
    "def plot_learning_curves(record_dict, sample_step=500):\n",
    "    # 将训练记录转换为 Pandas DataFrame，并设置 step 列为索引。然后对数据进行采样，步长为 sample_step\n",
    "    # pd.DataFrame(record_dict[\"train\"]): 将训练记录转换为 DataFrame。\n",
    "    # .set_index(\"step\"): 将 step 列设置为索引。\n",
    "    # .iloc[::sample_step]: 对数据进行采样，每隔 sample_step 步取一个样本。\n",
    "    # 减少数据点的数量，使曲线更清晰，同时保留趋势\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "\n",
    "    # 将验证记录转换为 Pandas DataFrame，并设置 step 列为索引\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "\n",
    "    # 计算训练 DataFrame 的列数，即需要绘制的性能指标数量\n",
    "    # 确定需要创建的子图数量\n",
    "    fig_num = len(train_df.columns)\n",
    "\n",
    "    # 创建一个包含 fig_num 个子图的图形\n",
    "    # 为每个性能指标创建一个子图，方便对比\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(5 * fig_num, 5))\n",
    "\n",
    "    # 遍历训练 DataFrame 的每一列（即每个性能指标）。\n",
    "    # 使用 enumerate 获取列名和索引\n",
    "    for idx, item in enumerate(train_df.columns):\n",
    "        # train_df.index: x 轴数据（训练步数）。\n",
    "        # train_df[item]: y 轴数据（性能指标值）。\n",
    "        # label=f\"train_{item}\": 设置曲线的标签。\n",
    "        axs[idx].plot(train_df.index, train_df[item], label=f\"train_{item}\")\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=f\"val_{item}\")\n",
    "\n",
    "        axs[idx].grid()  # 在当前子图上添加网格线\n",
    "        axs[idx].legend()  # 在当前子图上添加图例\n",
    "\n",
    "        # 生成 x 轴的刻度数据，从 0 到最大步数，步长为 5000\n",
    "        x_data = range(0, train_df.index[-1], 5000)\n",
    "\n",
    "        axs[idx].set_xticks(x_data)  # 设置 x 轴的刻度位置\n",
    "\n",
    "        # 设置 x 轴的刻度标签，将步数转换为“k”格式（如 5000 → \"5k\"）\n",
    "        # map(lambda x: f\"{int(x / 1000)}k\", x_data): 将刻度数据转换为“k”格式。\n",
    "        axs[idx].set_xticklabels(map(lambda x: f\"{int(x / 1000)}k\", x_data))\n",
    "\n",
    "        axs[idx].set_xlabel(\"step\")  # 设置 x 轴的标签为“step”\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "plot_learning_curves(record, sample_step=500)"
   ],
   "id": "a74c32989540c34",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 14
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T02:21:27.167328Z",
     "start_time": "2025-02-07T02:21:26.173444Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# dataload for evaluating\n",
    "#推理时alphadropout的p值是0，通过加dropout，一定程度解决了过拟合\n",
    "# load checkpoints\n",
    "model.load_state_dict(torch.load(\"checkpoints/dropout/best.ckpt\", weights_only=True, map_location=\"cpu\"))\n",
    "\n",
    "model.eval()\n",
    "loss, acc = evaluating(model, val_loader, loss_fct)\n",
    "print(f\"loss:     {loss:.4f}\\naccuracy: {acc:.4f}\")"
   ],
   "id": "c20bcbde0c67ab40",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss:     0.3623\n",
      "accuracy: 0.8887\n"
     ]
    }
   ],
   "execution_count": 15
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T02:21:27.169545Z",
     "start_time": "2025-02-07T02:21:27.167328Z"
    }
   },
   "cell_type": "code",
   "source": "",
   "id": "4a62054811a449ea",
   "outputs": [],
   "execution_count": 15
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
